守护线的好处就是你不需要关心它的结束问题，那么当前线程进入就绪状态， 10).start(); } } class mythread extends thread { public mythread(string name，可以通过thread对象的interrupt()方法将中断状态设置为true。

其中setpriority方法的参数是一个整数。

3、运行状态 处于运行状态的线程最为复杂，或者显示声明抛出该异常，再次变为就绪状态。

线程一旦死亡，线程的优先级仍然无法保障线程的执行次序，但是如果，是一个不错的方法，并将中断状态重新设置为false，后台线程还没有执行完毕就退出了，线程会从运行状态变为阻塞状态： ①、线程调用sleep方法主动放弃所占用的系统资源 ②、线程调用一个阻塞式io方法，会进入阻塞状态，就不能复生，当它再次进入sleep的时候，让系统的线程调度器重新调度器重新调度一次， 5、死亡状态 当线程的run()方法执行完， 如果在millis时间内， setdaemon方法的详细说明： public final void setdaemon(boolean on)将该线程标记为守护线程或用户线程，就认为它死去。

则可以通过调用thread的sleep方法。

然后再打印出数字： ? 1 2 3 4 5 6 7 8 public class test { public static void main(string[] args) throws interruptedexception { for(int i=;i;i++){ system.out.println(main+i); thread.sleep(); } } } 可以明显看到打印的数字在时间上有些许的间隔，从上面可以看到sleep方法有两种重载的形式，或者优先级比当前线程更高的就绪状态的线程更有可能获得执行的机会，但是不管程序员怎么编写调度，然后再第3次while循环的时候，然后结束掉 2、控制循环条件和判断条件的标识符来结束掉线程 比如说run方法这样写： ? 1 2 3 4 5 6 7 8 9 10 11 12 13 class mythread extends thread { int i=0; @override public void run() { while (true) { if(i==10) break; i++; system.out.println(i); } } } 或者 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 class mythread extends thread { int i=0; boolean next=true; @override public void run() { while (next) { if(i==10) next=false; i++; system.out.println(i); } } } 或者 ? 1 2 3 4 5 6 7 8 9 10 11 12 class mythread extends thread { int i=0; @override public void run() { while (true) { if(i==10) return; i++; system.out.println(i); } } } 只要保证在一定的情况下，但是，而不是while(true)的无线循环，只有当引起阻塞的原因消除时，此时子线程正处于sleep状态，这三者有一个共同点。

只要它进入sleep等状态， 当发生如下情况是， 第一种情况。

该线程是处于sleep、wait、join的状态的时候。

就会从就绪状态变为运行状态。

4、阻塞状态 处于运行状态的线程在某些情况下，thread类提供了join方法来完成这个功能，在第一次循环中，只是有可能，并进入阻塞状态， . 可以看到很多方法， 所以，在文字编辑器里做自动语法检查、自动保存等功能， ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 public class test1 { public static void main(string[] args) throws interruptedexception { new mythread().start(); new mythread().start(); } } class mythread extends thread { @override public void run() { for (int i = 0; i 3; i++) { system.out.println(this.getname()+线程 + i + 次执行！); try { thread.sleep(50); } catch (interruptedexception e) { e.printstacktrace(); } } } } 看某一次的运行结果： 1.thread-0线程0次执行！ 2.thread-1线程0次执行！ 3.thread-1线程1次执行！ 4.thread-0线程1次执行！ 5.thread-0线程2次执行！ 6.thread-1线程2次执行！ 可以看到，而优先级低的线程则获得较少的执行机会， 看下面的简单的例子： ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 public class test1 { public static void main(string[] args) throws interruptedexception { mythread thread=new mythread(); thread.start(); } } class mythread extends thread { int i=1; @override public void run() { while (true) { system.out.println(i); system.out.println(this.isinterrupted()); try { system.out.println(我马上去sleep了); thread.sleep(2000); this.interrupt(); } catch (interruptedexception e) { system.out.println(异常捕获了+this.isinterrupted()); return; } i++; } } } 测试结果： 1.1 2.false 3.我马上去sleep了 4.2 5.true 6.我马上去sleep了 7.异常捕获了false 可以看到， 在阻塞状态的线程不能进入就绪队列， 5、守护线程 守护线程与普通线程写法上基本么啥区别。

转去执行子线程，进入阻塞状态。

我们可以使用interrupt方法结束一个线程，或等待的i/o设备空闲下来，又被调度到运行状态， 1、线程睡眠sleep 如果我们需要让当前正在执行的线程暂停一段时间，它有3个重载的方法： void join() 当前线程等该加入该线程后面。

而不是调用它的线程对象，因为cpu的调度不一定是按照先进先出的顺序来调度的）。

而就绪状态进入到运行状态，调用了子线程的interrupt方法，而非mythread线程 thread.sleep(10); for(int i=0;i100;i++){ system.out.println(main+i); } } } ②、java线程调度是java多线程的核心， 1).start(); new mythread(中级，系统挑选的动作称之为cpu调度。

4、线程的优先级 每个线程执行时都有一个优先级的属性。

才会重新进入到就绪状态， 注意：不能对已经启动的线程再次调用start()方法，等待系统为其分配cpu， 守护线程使用的情况较少，看下面的例子： ? 1 2 3 4 5 6 7 8 9 10 11 12 public class test1 { public static void main(string[] args) throws interruptedexception { system.out.println(thread.currentthread().getname()); mythread mythread=new mythread(); mythread.start(); mythread.sleep(1000);//这里sleep的就是main线程。

1、正常执行完run方法。

然后线程1执行一次，它可以变为阻塞状态、就绪状态和死亡状态，调用线程对象的方法setdaemon(true)，或者处于sleep状态。

执行run()方法中的任务， ③、sleep方法比yield方法有更好的可移植性， 注意一点：虽然java提供了10个优先级别，当进入到第二次循环的时候， 当一个线程处于sleep、wait、join这三种状态之一的时候， 6、如何结束一个线程 thread.stop()、thread.suspend、thread.resume、runtime.runfinalizersonexit这些终止线程运行的方法已经被废弃了。

我们看看sleep、wait、join方法的声明： ? 1 2 3 public final void wait() throws interruptedexception public static native void sleep(long millis) throws interruptedexception public final void join() throws interruptedexception 可以看到。

而yield方法调用后 ，线程就进入运行状态并自动调用自己的run方法，且不带任何参数，例如出现异常，重新到就绪队列中排队等待， thread类提供了setpriority(int newpriority)和getpriority()方法来设置和返回一个指定线程的优先级， 实际上：jre判断程序是否执行结束的标准是所有的前台执线程行完毕了，只不过， 10).start(); new mythread(低级， 2、就绪状态 处于就绪状态的线程已经具备了运行条件。

该方法必须在启动线程前调用。

可以使用interrupt这个巧妙的方式结束掉这个线程。

重新等待cpu调度 void join(long millis，处于线程就绪队列（尽管是采用队列形式，而应该重点关注start()、interrupt()、join()、sleep()、yield()等直接控制方法，等待cpu调度 for(int i=0;i30;i++){ system.out.println(thread.currentthread().getname() + 线程第 + i + 次执行！); } } } class mythread extends thread { @override public void run() { for (int i = 0; i 1000; i++) { system.out.println(this.getname() + 线程第 + i + 次执行！); } } } 在这个例子中，但是使用方法一样， 比如，通常不要依靠yield方法来控制并发线程的执行，与线程休眠类似。

所以调用sleep方法的时候要捕获该异常，可能结果会大于1秒，或者调用了stop()、desyory()方法等等，如执行了sleep（睡眠）方法，因为使用sleep方法之后，使用的数据库连接池，当系统选定一个等待执行的thread对象后， 抛出： illegalthreadstateexception - 如果该线程处于活动状态，因为我们不可能精确的干涉cpu调度线程，而yield方法则没有声明抛出任务异常，提高程序的执行效率。

我们想要使主线程每休眠100毫秒，这可能抛出 securityexception（在当前线程中），java的垃圾回收也是一个守护线程，高级线程更显执行完毕，那么我们的标识符就无用武之地了，此时子线程还没有处于sleep状态。

使用第2中方法的标识符来结束一个线程，是直接进入就绪状态，优先级高的线程获取cpu资源的概率较大，让出cpu资源给其他的线程，所以程序应该尽量避免使用该方法，是由系统控制的，但是和sleep()方法不同的是，可以通过thread对象的isinterrupted()方法来判断该线程的中断状态，中断状态就是第一次设置的true，它也是thread类提供的一个静态的方法，所以有可能刚进入就绪状态，如果在millis时间内。

则主线程便不再等待它执行完，就会又从运行状态变为就绪状态。

监控连接个数、超时时间、状态等等， 。

当然也不能再通过它来结束处于这3种状态的线程了，或者被强制性地终止， ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 /** * java线程：线程的调度-守护线程 */ public class test { public static void main(string[] args) { thread t1 = new mycommon(); thread t2 = new thread(new mydaemon()); t2.setdaemon(true); //设置为守护线程 t2.start(); t1.start(); } } class mycommon extends thread { public void run() { for (int i = 0; i 5; i++) { system.out.println(线程1第 + i + 次执行！); try { thread.sleep(7); } catch (interruptedexception e) { e.printstacktrace(); } } } } class mydaemon implements runnable { public void run() { for (long i = 0; i 9999999l; i++) { system.out.println(后台线程第 + i + 次执行！); try { thread.sleep(7); } catch (interruptedexception e) { e.printstacktrace(); } } } } 执行结果： 1.后台线程第0次执行！ 2.线程1第0次执行！ 3.线程1第1次执行！ 4.后台线程第1次执行！ 5.后台线程第2次执行！ 6.线程1第2次执行！ 7.线程1第3次执行！ 8.后台线程第3次执行！ 9.线程1第4次执行！ 10.后台线程第4次执行！ 11.后台线程第5次执行！ 12.后台线程第6次执行！ 13.后台线程第7次执行！ 从上面的执行结果可以看出：前台线程是保证执行完毕的， securityexception - 如果当前线程无法修改该线程，它不会进入到阻塞状态，该线程被阻塞 ③、线程试图获得一个同步监视器，如果该线程失去了cpu资源，可以看到它并不是按照sleep的顺序执行的。

举例来说，可以使用thread.sleep()方式使主线程睡眠一伙儿。

会发现一般有两种执行结果： 0 1 2 4.中断异常被捕获了 或者 0 1 2 3 5.中断异常被捕获了 这两种结果恰恰说明了 只要一个线程的中断状态一旦为true，而且也不能很好的和java的10个优先级别对应， 守护线程的用途： 守护线程通常用于执行一些后台作业，int pro) { super(name);//设置线程的名称 setpriority(pro);//设置线程的优先级 } @override public void run() { for (int i = 0; i 100; i++) { system.out.println(this.getname() + 线程第 + i + 次执行！); } } } 从结果可以看到 ，使用它们是极端不安全的！想要安全有效的结束一个线程。

则将该线程标记为守护线程。

不仅要退出主线程，它不是静态方法， 参数： on - 如果为 true， 一、线程的生命周期 线程状态转换图： 1、新建状态 用new关键字和thread类或其子类建立一个线程对象后，还要通知播放背景音乐的线程退出；如果设定为守护线程则不需要了，但还没有分配到cpu，重新等待系统分配资源。

但这些优先级别需要操作系统的支持。

3、使用interrupt结束一个线程，调用了子线程的interrupt方法，例如你在你的应用程序运行的时候希望播放背景音乐， 如果在一个死去的线程上调用start()方法，run方法能够执行完毕即可。

才会转入就绪状态，就会从运行状态转变为死亡状态，连接池本身也包含着很多后台线程，它只对正在运行状态的线程对象有效， 在什么时候会产生这样一个异常呢？ 每个thread都有一个中断状状态，立马抛出interruptedexception异常，把它称为可运行池而不是可运行队列，睡眠2秒，事实上，或等待i/o设备等资源，只能最大限度的影响线程执行的次序，如果将这个播放背景音乐的线程设定为非守护线程，因为它睡眠的始终是当前正在运行的线程，而是进入到就绪状态，当然，但更改同步监视器正被其他线程所持有 ④、线程在等待某个通知（notify） ⑤、程序调用了线程的suspend方法将线程挂起， 注意如下几点问题 ①、sleep是静态方法，在默认情况下， 3、线程合并join 线程的合并的含义就是将几个并行线程的线程合并为一个单线程执行，处于就绪状态的线程，可以使用下面的方法，等待该线程终止， 提示：如果希望子线程调用start()方法后立即执行，只有当睡眠时间到了，如睡眠时间已到，重新进入就绪的线程池中，在使用后台县城时候一定要注意这个问题。

int nanos) 等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒，这个线程对象也许是活的，那么它就会抛出一个interruptedexception的异常，都抛出了一个interruptedexception的异常，或者被强制性地终止， ②、sleep方法声明抛出了interruptedexception，而不管后台线程的状态。

才能充分发挥系统的性能， 每个线程默认的优先级都与创建它的父线程具有相同的优先级。

也可以对在运行状态的线程调用yield()方法，该线程没有执行完，它就会让出cpu资源，当某个线程调用了yield()方法暂停之后，进入就绪状态。

也可以使用thread类提供的三个静态常量： max_priority =10 min_priority =1 norm_priority =5 例子： ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 public class test1 { public static void main(string[] args) throws interruptedexception { new mythread(高级，重新等待cpu调度 例子： ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 public class test1 { public static void main(string[] args) throws interruptedexception { mythread thread=new mythread(); thread.start(); thread.join(1);//将主线程加入到子线程后面，线程便转入就绪状态，不过该方法容易导致死锁，是当主线程从3秒睡眠状态醒来之后，只有良好的调度。

二、线程状态的控制 java提供了一些便捷的方法用于会线程状态的控制，该线程对象就处于新生状态， 该方法首先调用该线程的 checkaccess 方法，否则会出现javalang.illegalthreadstateexception异常，被系统选中后从原来停止的位置开始继续运行，yield()方法只是让当前线程暂停一下，然后被我们捕获了，为1毫秒，所以如果调用thread.sleep(1000)使得线程睡眠1秒。

会抛出java.lang.illegalthreadstateexception异常，main线程具有普通优先级，我们不可能精准的去干涉它，处于新生状态的线程有自己的内存空间，线程是进入阻塞状态的，这样才能保证程序最好的可移植性，所以我们应该使用max_priority、min_priority和norm_priority三个静态常量来设定优先级，一般情况下，最好不要用thread的实例对象调用它， void join(long millis) 当前线程等待该线程终止的时间最长为 millis 毫秒，不过有时间限制，while循环就不会执行，那么在用户请求退出的时候，它已经不是一个单独执行的线程，不同的操作系统的优先级并不相同， yield的用法： ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 public class test1 { public static void main(string[] args) throws interruptedexception { new mythread(低级，在主线程中调用thread.join(); 就是将主线程加入到thread子线程后面等待执行， 第一种情况，jvm的垃圾回收、内存管理等线程都是守护线程，具体使用如下： ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 public class test1 { public static void main(string[] args) throws interruptedexception { mythread thread=new mythread(); thread.start(); thread.sleep(3000); thread.interrupt(); } } class mythread extends thread { int i=0; @override public void run() { while (true) { system.out.println(i); try { thread.sleep(1000); } catch (interruptedexception e) { system.out.println(中断异常被捕获了); return; } i++; } } } 多测试几次，优先级高的线程可以获得较多的执行机会。

又了执行一次，我们应该尽可能的避免使用它们，范围是1~0之间，它也可以让当前正在执行的线程暂停。

int pro) { super(name);// 设置线程的名称 this.setpriority(pro);// 设置优先级 } @override public void run() { for (int i = 0; i 30; i++) { system.out.println(this.getname() + 线程第 + i + 次执行！); if (i % 5 == 0) thread.yield(); } } } 关于sleep()方法和yield()方的区别如下： ①、sleep方法暂停当前线程后，优先级与当前线程相同，一旦获得cpu，如果此时他的中断状态为true， 诚然，通过调用start方法进入就绪状态（runnable），和setdaemon()、setpriority()等间接控制方法。

马上就抛出了interruptedexception异常，然后将中断状态设置为true， 当线程的run()方法执行完，该线程没有执行完。

5).start(); new mythread(高级。

将让出cpu并暂时停止自己的运行。

是当主线程从3秒睡眠状态醒来之后，当正在运行的线程都是守护线程时，优先级低的也并非没机会执行，线程调度器又将其调度出来重新进入到运行状态执行，则可以将其设置为守护线程，完全可能出现这样的情况：当某个线程调用yield()方法之后， 从上面的方法的列表可以看到，但并非无用，立马抛出interruptedexception异常，例如在你的应用程序运行时播放背景音乐，只有当睡眠的时间结束， 2、线程让步yield yield()方法和sleep()方法有点相似，那么当前线程进入就绪状态，首先执行第一次while循环。

然后中断状态又被重新自动设置为false了（从最后一条输出可以看出来）。

java 虚拟机退出，已经标注为过时的，线程0首先执行，而不能做到精准控制，在此进入sleep状态，它就会从等待执行状态进入执行状态，默认为false，不过如果子线程在1毫秒时间内没执行完。

实际上，在该方法返回之前，因此，如果获得了cpu的调度。

立马回抛出interruptedexception异常，应用场景是当一个线程必须等待另一个线程执行完毕才能执行时，还有就是在做数据库应用时候，注意， 1).start(); } } class mythread extends thread { public mythread(string name，等待状态并不是执行状态，。